// 嵌套3层对象
export const selector3 = (res) => {
  // 取出我们传入的数据
  const { oneId, twoIds, twoId, threeId, arrOneData, arrTwoData, arrThreeData } = res

  // 用于存放唯一Id
  let arrTwos = []
  // 最终返回数组
  let result = []
  // 第一次循环出子级
  arrTwoData.forEach((j) => {
    // 循环出孙子
    arrThreeData.forEach((k) => {
      // 声明第三级 方便后面使用
      let objArr = {
        value: k.value,
        label: k.label
      }
      // 如果第二级的id等于第三级的threeId
      if (j[twoIds] == k[threeId]) {
        // includes查询是否存在，存在返回true，否则返回false
        // 如果arrTwos不存在j.id 表示第一次循环到该id
        if (arrTwos.includes(j[twoIds]) == false) {
          // 声明第二级 方便后面使用
          let obj = {
            twoId: j[twoId],
            value: j.value,
            label: j.label,
            // children 存放相同threeId的第三级
            children: []
          }
          // 将第三级插入第二级的children中
          obj.children.push(objArr)
          // 将处理好的obj插入result数组中
          result.push(obj)
          // 在arrTwos添加当前第二级id
          arrTwos.push(j[twoIds])
        } else {
          //如果存在id则说明已经执行过，直接将第三级数据插入第二级children中
          // indexOf 查询当前j.id在arrTwos中的位置，让数据正确插入
          let index = arrTwos.indexOf(j[twoIds])
          result[index].children.push(objArr)
        }
      }
    })
    // 第二级没有子级的情况
    // 判断是否执行过，没有则执行
    if (arrTwos.includes(j[twoIds]) == false) {
      let obj = {
        twoId: j[twoId],
        value: j.value,
        label: j.label
      }
      // 直接将第二级插入result中
      result.push(obj)
    }
  })

  // 用于存放唯一Id
  let arrOnes = []
  // 最终返回数组
  let resultFaters = []
  // 第二次循环 将第二级插入对应的第一级中
  arrOneData.forEach((i) => {
    result.forEach((k) => {
      // 如果第一级id等于第二级twoId
      if (i[oneId] == k.twoId) {
        let ArrResult = {
          value: k.value,
          label: k.label,
          children: k.children
        }
        // 如果arrOnes不存在j.id 表示第一次循环到该id
        if (arrOnes.includes(i[oneId]) == false) {
          let obj = {
            value: i.value,
            label: i.label,
            children: []
          }
          obj.children.push(ArrResult)
          resultFaters.push(obj)
          arrOnes.push(i[oneId])
        } else {
          //如果存在id则说明已经执行过，直接将第三级数据插入第二级children中
          let index = arrOnes.indexOf(i[oneId])
          resultFaters[index].children.push(ArrResult)
        }
      }
    })
    // 第一级没有子级的情况
    // 判断是否执行过，没有则执行
    if (arrOnes.includes(i[oneId]) == false) {
      let obj = {
        value: i.value,
        label: i.label
      }
      resultFaters.push(obj)
    }
  })

  return resultFaters
}

// 过滤保存只有班级的数据
export const filterList3 = (list) => {
  let newList = []
  // 去除第一层无 children 属性的对象
  for (let i = 0; i < list.length; i++) {
    if (list[i]?.children) {
      newList.push(list[i])
    }
  }
  // 去除第二层无 children 属性的对象
  for (let i = 0; i < newList.length; i++) {
    let newChildren = []
    for (let j = 0; j < newList[i].children.length; j++) {
      // newList[i].children[j].hasOwnProperty('children')
      if (newList[i].children[j].children) {
        newChildren.push(newList[i].children[j])
      }
    }
    newList[i].children = newChildren
  }
  return newList
}

// 嵌套2层对象
export const selector2 = (res) => {
  // 取出我们传入的数据
  const { oneId, twoIds, twoId, arrOneData, arrTwoData } = res

  // 用于存放唯一Id
  let arrTwos = []
  // 最终返回数组
  let result = []
  // 第一次循环出子级
  arrTwoData.forEach((j) => {
    // 第二级没有子级的情况
    // 判断是否执行过，没有则执行
    if (arrTwos.includes(j[twoIds]) == false) {
      let obj = {
        twoId: j[twoId],
        value: j.value,
        label: j.label
      }
      // 直接将第二级插入result中
      result.push(obj)
    }
  })

  // 用于存放唯一Id
  let arrOnes = []
  // 最终返回数组
  let resultFaters = []
  // 第二次循环 将第二级插入对应的第一级中
  arrOneData.forEach((i) => {
    result.forEach((k) => {
      // 如果第一级id等于第二级twoId
      if (i[oneId] == k.twoId) {
        let ArrResult = {
          value: k.value,
          label: k.label,
          children: k.children
        }
        // 如果arrOnes不存在j.id 表示第一次循环到该id
        if (arrOnes.includes(i[oneId]) == false) {
          let obj = {
            value: i.value,
            label: i.label,
            children: []
          }
          obj.children.push(ArrResult)
          resultFaters.push(obj)
          arrOnes.push(i[oneId])
        } else {
          //如果存在id则说明已经执行过，直接将第三级数据插入第二级children中
          let index = arrOnes.indexOf(i[oneId])
          resultFaters[index].children.push(ArrResult)
        }
      }
    })
    // 第一级没有子级的情况
    // 判断是否执行过，没有则执行
    if (arrOnes.includes(i[oneId]) == false) {
      let obj = {
        value: i.value,
        label: i.label
      }
      resultFaters.push(obj)
    }
  })
  return resultFaters
}

// 过滤保存有 专业 的数据（保留有专业的学院）
export const filterList2 = (list) => {
  let newList = []
  for (let i = 0; i < list.length; i++) {
    if (list[i]?.children) {
      newList.push(list[i])
    }
  }
  return newList
}

// 生成级联选择器组件需要的数据格式，并且是只保留有班级的学院
export const generateCascaderData = (colleges, majors, classes) => {
  const validMajors = majors.filter(major => classes.some(cls => cls.mid === major.id));
  const validColleges = colleges.filter(college => validMajors.some(major => major.cid === college.id));

  return validColleges.map(college => ({
    label: college.label,
    value: college.value,
    children: validMajors.filter(major => major.cid === college.id).map(major => ({
      label: major.label,
      value: major.value,
      children: classes.filter(cls => cls.mid === major.id).map(cls => ({
        label: cls.label,
        value: cls.value
      }))
    }))
  }));
}